// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package atomic

import "unsafe"

// Int32是一个原子访问的Int32值。禁止复制Int32。
type Int32 struct {
	noCopy noCopy
	value  int32
}

// Load以原子方式访问并返回值。
func (i *Int32) Load() int32 {
	return Loadint32(&i.value)
}

// 存储以原子方式更新值。
func (i *Int32) Store(value int32) {
	Storeint32(&i.value, value)
}

// CompareAndSwap以原子方式将i的值与旧值进行比较，如果它们相等，则将i的值与新值进行交换。
// 
// 如果操作成功，则返回true。
func (i *Int32) CompareAndSwap(old, new int32) bool {
	return Casint32(&i.value, old, new)
}

// Swap将i的值替换为新值，返回替换前的
// i的值。
func (i *Int32) Swap(new int32) int32 {
	return Xchgint32(&i.value, new)
}

// Add将delta原子地添加到i中，返回新的更新值
// 。
// 
// 此操作以通常的
// 两位补的方式结束。
func (i *Int32) Add(delta int32) int32 {
	return Xaddint32(&i.value, delta)
}

// Int64是一个原子访问的Int64值。禁止复制Int64。
type Int64 struct {
	noCopy noCopy
	value  int64
}

// Load以原子方式访问并返回值。
func (i *Int64) Load() int64 {
	return Loadint64(&i.value)
}

// 存储以原子方式更新值。
func (i *Int64) Store(value int64) {
	Storeint64(&i.value, value)
}

// CompareAndSwap以原子方式将i的值与旧值进行比较，如果它们相等，则将i的值与新值进行交换。
// 
// 如果操作成功，则返回true。
func (i *Int64) CompareAndSwap(old, new int64) bool {
	return Casint64(&i.value, old, new)
}

// Swap将i的值替换为新值，返回替换前的
// i的值。
func (i *Int64) Swap(new int64) int64 {
	return Xchgint64(&i.value, new)
}

// Add将delta原子地添加到i中，返回新的更新值
// 。
// 
// 此操作以通常的
// 两位补码方式结束。
func (i *Int64) Add(delta int64) int64 {
	return Xaddint64(&i.value, delta)
}

// Uint8是一个原子访问的Uint8值。
// 
// 不能复制单元8。
type Uint8 struct {
	noCopy noCopy
	value  uint8
}

// Load以原子方式访问并返回值。
func (u *Uint8) Load() uint8 {
	return Load8(&u.value)
}

// 存储以原子方式更新值。
func (u *Uint8) Store(value uint8) {
	Store8(&u.value, value)
}

// 取值并用u值执行位
// ”和“运算，将结果存储到u中。
// 
// 整个过程以原子方式执行。
func (u *Uint8) And(value uint8) {
	And8(&u.value, value)
}

// Or取值，用u的值执行位
// “Or”运算，将结果存储到u中。
// 
// 整个过程以原子方式执行。
func (u *Uint8) Or(value uint8) {
	Or8(&u.value, value)
}

// Uint32是一个原子访问的Uint32值。
// 
// Uint32不能被复制。
type Uint32 struct {
	noCopy noCopy
	value  uint32
}

// Load以原子方式访问并返回值。
func (u *Uint32) Load() uint32 {
	return Load(&u.value)
}

// LoadAcquire是一个部分不同步的版本
// Load，它放松了排序约束。其他线程
// 可能会观察到此操作之前到
// 之后发生的操作，但不能观察到在此线程上的
// 之后发生的任何操作在其之前发生。
// 
// 警告：谨慎使用。
func (u *Uint32) LoadAcquire() uint32 {
	return LoadAcq(&u.value)
}

// 存储以原子方式更新值。
func (u *Uint32) Store(value uint32) {
	Store(&u.value, value)
}

// StoreRelease是部分不同步的Store版本
// ，它放松了订购限制。其他线程
// 可能会观察到在此操作之后发生的操作，但不能观察到在此操作之前发生的任何操作。
// 
// 警告：谨慎使用。
func (u *Uint32) StoreRelease(value uint32) {
	StoreRel(&u.value, value)
}

// CompareAndSwap以原子方式将u的值与旧值进行比较，如果它们相等，则将u的值与新值进行交换。
// 
// 如果操作成功，则返回true。
func (u *Uint32) CompareAndSwap(old, new uint32) bool {
	return Cas(&u.value, old, new)
}

// CompareAndSwapRelease是Cas的部分非同步版本
// ，它放松了排序约束。其他线程
// 可能会观察到该操作之后发生的操作，但不能观察到该线程之前发生的任何操作。
// 
// 如果操作成功，则返回true。
// 
// 警告：谨慎使用。
func (u *Uint32) CompareAndSwapRelease(old, new uint32) bool {
	return CasRel(&u.value, old, new)
}

// Swap将u的值替换为新值，返回替换前的
// u的值。
func (u *Uint32) Swap(value uint32) uint32 {
	return Xchg(&u.value, value)
}

// 取值并用u值执行位
// ”和“运算，将结果存储到u中。
// 
// 整个过程以原子方式执行。
func (u *Uint32) And(value uint32) {
	And(&u.value, value)
}

// Or取值，用u值执行按位
// “Or”运算，将结果存储到u中
// 
// 整个过程以原子方式执行。
func (u *Uint32) Or(value uint32) {
	Or(&u.value, value)
}

// Add将delta原子地添加到u，返回新的更新值
// 。
// 
// 此操作以通常的
// two's-complete方式结束。
func (u *Uint32) Add(delta int32) uint32 {
	return Xadd(&u.value, delta)
}

// Uint64是一个原子访问的Uint64值。
// 
// Uint64不能被复制。
type Uint64 struct {
	noCopy noCopy
	value  uint64
}

// Load以原子方式访问并返回值。
func (u *Uint64) Load() uint64 {
	return Load64(&u.value)
}

// 存储以原子方式更新值。
func (u *Uint64) Store(value uint64) {
	Store64(&u.value, value)
}

// CompareAndSwap以原子方式将u的值与旧值进行比较，如果它们相等，则将u的值与新值进行交换。
// 
// 如果操作成功，则返回true。
func (u *Uint64) CompareAndSwap(old, new uint64) bool {
	return Cas64(&u.value, old, new)
}

// Swap将u的值替换为新值，返回替换前的
// u的值。
func (u *Uint64) Swap(value uint64) uint64 {
	return Xchg64(&u.value, value)
}

// Add将delta原子地添加到u，返回新的更新值
// 。
// 
// 此操作以通常的
// 两位补码方式结束。
func (u *Uint64) Add(delta int64) uint64 {
	return Xadd64(&u.value, delta)
}

// uintpttr是一个原子访问的uintpttr值。禁止复制Uintptr。
type Uintptr struct {
	noCopy noCopy
	value  uintptr
}

// Load以原子方式访问并返回值。
func (u *Uintptr) Load() uintptr {
	return Loaduintptr(&u.value)
}

// LoadAcquire是部分不同步的版本
// Load，它放松了排序约束。其他线程
// 可能会观察到此操作之前到
// 之后发生的操作，但不能观察到此线程上在其之后发生的任何操作
// 在其之前发生。
// 
// 警告：谨慎使用。
func (u *Uintptr) LoadAcquire() uintptr {
	return LoadAcquintptr(&u.value)
}

// 存储以原子方式更新值。
func (u *Uintptr) Store(value uintptr) {
	Storeuintptr(&u.value, value)
}

// StoreRelease是部分不同步的Store版本
// ，它放松了订购限制。其他线程
// 可能会观察到该操作之后发生的操作，但不能观察到该线程之前发生的任何操作。
// 
// 警告：谨慎使用。
func (u *Uintptr) StoreRelease(value uintptr) {
	StoreReluintptr(&u.value, value)
}

// CompareAndSwap以原子方式将u的值与旧值进行比较，如果它们相等，则将u的值与新值进行交换。
// 
// 如果操作成功，则返回true。
func (u *Uintptr) CompareAndSwap(old, new uintptr) bool {
	return Casuintptr(&u.value, old, new)
}

// 交换将u的值替换为新值，返回
// 替换前u的值。
func (u *Uintptr) Swap(value uintptr) uintptr {
	return Xchguintptr(&u.value, value)
}

// Add将delta以原子方式添加到u，返回
// 新的更新值。
// 
// 此操作以通常的
// two's-complete方式结束。
func (u *Uintptr) Add(delta uintptr) uintptr {
	return Xadduintptr(&u.value, delta)
}

// Float64是一个原子访问的Float64值。
// 
// 不能复制浮点64。
type Float64 struct {
	u Uint64
}

// Load以原子方式访问并返回值。cun chu defg
func (f *Float64) Load() float64 {
	r := f.u.Load()
	return *(*float64)(unsafe.Pointer(&r))
}

func (f *Float64) Store(value float64) {
	f.u.Store(*(*uint64)(unsafe.Pointer(&value)))
}

// UnsafePointer是一个原子访问的不安全指针。指针值。
// 
// 请注意，由于原子性保证，这种类型的值
// 的存储永远不会触发写入障碍，相关
// 方法的后缀为“NoWB”以明确表示这一点。
// 因此，应该谨慎地使用这种类型，并且尽量少使用
// 大多数情况下使用的值都不在Go堆中。
// 
// 不能复制未安全的指针。
type UnsafePointer struct {
	noCopy noCopy
	value  unsafe.Pointer
}

// Load以原子方式访问并返回值。
func (u *UnsafePointer) Load() unsafe.Pointer {
	return Loadp(unsafe.Pointer(&u.value))
}

// StoreNoWB以原子方式更新值。
// 
// 警告：顾名思义，此操作不*不*
// 对值执行写屏障，因此此操作可能会对GC隐藏指针。谨慎使用。
// 使用Go堆中找不到的值是安全的。
func (u *UnsafePointer) StoreNoWB(value unsafe.Pointer) {
	StorepNoWB(unsafe.Pointer(&u.value), value)
}

// 原子比较（相对于其他方法）
// 将u的值与旧值进行比较，如果它们相等，
// 将u的值与新值进行交换。
// 
// 如果操作成功，则返回true。
// 
// 警告：顾名思义，此操作不*不*
// 对值执行写屏障，因此此操作可能会对GC隐藏指针。谨慎使用。
// 使用Go堆中找不到的值是安全的。
func (u *UnsafePointer) CompareAndSwapNoWB(old, new unsafe.Pointer) bool {
	return Casp1(&u.value, old, new)
}

// 在第一次使用后，不得将副本嵌入结构中。
// 参见https:
// 详细信息。
type noCopy struct{}

// 锁是“go vet”中的-copylocks检查器使用的不可操作的锁。
func (*noCopy) Lock()   {}
func (*noCopy) Unlock() {}
